#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdbool.h>


 // Definition for a binary tree node.

 // struct TreeNode {
 //     int val;
 //    struct TreeNode *left;
 //   struct TreeNode *right;
 //};


bool flag = true;

//bool flag = true;
//
//int maxDepth(struct TreeNode* root) {
//    if (root == NULL)
//    {
//        return 0;
//    }
//    int len1 = maxDepth(root->left);
//    int len2 = maxDepth(root->right);
//    return  len1 > len2 ? len1 + 1 : len2 + 1;
//}
//
//
//bool isBalanced(struct TreeNode* root) {
//    if (root == NULL)
//    {
//        return true;
//    }
//    if (flag == false)
//    {
//        return false;
//    }
//
//    int leftdepth = maxDepth(root->left);
//    int rightdepth = maxDepth(root->right);
//    if (abs(leftdepth - rightdepth) > 1)
//    {
//        flag = false;
//    }
//
//    return  isBalanced(root->left) && isBalanced(root->right);
//
//}

int main()
{

    isBalanced(root);
	printf("%d\n",flag);
	return 0;
}




//bool isSymmetricsubTree(struct TreeNode* root1, struct TreeNode* root2)
//{
//    if (root1 == NULL && root2 == NULL)
//    {
//        return true;
//    }
//
//    if (root1 == NULL || root2 == NULL)
//    {
//        return false;
//    }
//
//    if (root1->val != root2->val)
//    {
//        return false;
//    }
//    return isSymmetricsubTree(root1->right, root2->left) &&
//        isSymmetricsubTree(root1->left, root2->right);
//
//}
//
//bool isSymmetric(struct TreeNode* root) {
//
//    if (root == NULL)
//    {
//        return true;
//    }
//
//    return isSymmetricsubTree(root->left, root->right);
//
//}



//bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
//    if (p == NULL && q == NULL)
//    {
//        return true;
//    }
//    if (p == NULL || q == NULL)
//    {
//        return false;
//    }
//
//    if (p->val != q->val)
//    {
//        return false;
//    }
//
//    return isSameTree(p->left, q->left)
//        && isSameTree(p->right, q->right);
//
//}
//
//
//bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot) {
//
//    if (root == NULL)
//    {
//        return false;
//    }
//
//    if (isSameTree(root, subRoot))
//    {
//        return true;
//    }
//
//    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
//
//}

//#include <stdio.h>
//#include<stdlib.h>
//
//typedef char BTDataType;
//typedef struct BinaryTreeNode
//{
//    struct BinaryTreeNode* left;
//    struct BinaryTreeNode* right;
//    BTDataType data;
//
//}BTNode;
//
//
//BTNode* BuyNode(BTDataType x)
//{
//    BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
//    if (newnode == NULL)
//    {
//        perror("malloc fail");
//        exit(-1);
//    }
//    newnode->data = x;
//    newnode->left = NULL;
//    newnode->right = NULL;
//
//    return newnode;
//}
//
//BTNode* creattree(char a[], int* i)
//{
//    if (a[(*i)] == '#')
//    {
//        (*i)++;
//        return NULL;
//    }
//
//    BTNode* root = BuyNode(a[(*i)++]);
//    root->left = creattree(a, i);
//    root->right = creattree(a, i);
//    return root;
//
//}
//void inorder(BTNode* root)
//{
//    if (root == NULL)
//    {
//        return;
//    }
//
//    inorder(root->left);
//    printf("%c ", root->data);
//    inorder(root->right);
//
//}
//
//
//int main() {
//
//    char a[100] = { 0 };
//    scanf("%s", a);
//    int i = 0;
//    BTNode* root = creattree(a, &i);
//    inorder(root);
//
//    return 0;
//}

